"""
__move_one_output_direct_match_MDL.py_____________________________________________________

Automatically generated AToM3 Model File (Do not modify directly)
Author: levi
Modified: Fri Feb  1 09:56:35 2013
__________________________________________________________________________________________
"""
from stickylink import *
from widthXfillXdecoration import *
from MT_pre__MetaModelElement_S import *
from MT_pre__MatchModel import *
from MT_pre__match_contains import *
from MT_pre__directLink_S import *
from MT_post__match_contains import *
from MT_post__MetaModelElement_S import *
from MT_post__directLink_S import *
from MT_post__MatchModel import *
from RHS import *
from LHS import *
from graph_MT_pre__MetaModelElement_S import *
from graph_MT_post__MetaModelElement_S import *
from graph_MT_post__match_contains import *
from graph_LHS import *
from graph_MT_post__directLink_S import *
from graph_MT_pre__match_contains import *
from graph_MT_pre__MatchModel import *
from graph_MT_post__MatchModel import *
from graph_MT_pre__directLink_S import *
from graph_RHS import *
from ATOM3Enum import *
from ATOM3String import *
from ATOM3BottomType import *
from ATOM3Constraint import *
from ATOM3Attribute import *
from ATOM3Float import *
from ATOM3List import *
from ATOM3Link import *
from ATOM3Connection import *
from ATOM3Boolean import *
from ATOM3Appearance import *
from ATOM3Text import *
from ATOM3Action import *
from ATOM3Integer import *
from ATOM3Port import *
from ATOM3MSEnum import *

def move_one_output_direct_match_MDL(self, rootNode, MT_post__SimpleDSLTransMMRootNode=None, MoTifRuleRootNode=None, MT_pre__SimpleDSLTransMMRootNode=None):

    # --- Generating attributes code for ASG MT_post__SimpleDSLTransMM ---
    if( MT_post__SimpleDSLTransMMRootNode ): 
        # author
        MT_post__SimpleDSLTransMMRootNode.author.setValue('Annonymous')

        # description
        MT_post__SimpleDSLTransMMRootNode.description.setValue('\n')
        MT_post__SimpleDSLTransMMRootNode.description.setHeight(15)

        # name
        MT_post__SimpleDSLTransMMRootNode.name.setValue('')
        MT_post__SimpleDSLTransMMRootNode.name.setNone()
    # --- ASG attributes over ---


    # --- Generating attributes code for ASG MoTifRule ---
    if( MoTifRuleRootNode ): 
        # author
        MoTifRuleRootNode.author.setValue('Annonymous')

        # description
        MoTifRuleRootNode.description.setValue('\n')
        MoTifRuleRootNode.description.setHeight(15)

        # name
        MoTifRuleRootNode.name.setValue('MoveOneOutputDirectMatch')
    # --- ASG attributes over ---


    # --- Generating attributes code for ASG MT_pre__SimpleDSLTransMM ---
    if( MT_pre__SimpleDSLTransMMRootNode ): 
        # author
        MT_pre__SimpleDSLTransMMRootNode.author.setValue('Annonymous')

        # description
        MT_pre__SimpleDSLTransMMRootNode.description.setValue('\n')
        MT_pre__SimpleDSLTransMMRootNode.description.setHeight(15)

        # name
        MT_pre__SimpleDSLTransMMRootNode.name.setValue('')
        MT_pre__SimpleDSLTransMMRootNode.name.setNone()
    # --- ASG attributes over ---


    self.obj12014=MT_pre__MetaModelElement_S(self)
    self.obj12014.isGraphObjectVisual = True

    if(hasattr(self.obj12014, '_setHierarchicalLink')):
      self.obj12014._setHierarchicalLink(False)

    # MT_pivotOut__
    self.obj12014.MT_pivotOut__.setValue('element1')

    # MT_subtypeMatching__
    self.obj12014.MT_subtypeMatching__.setValue(('True', 1))
    self.obj12014.MT_subtypeMatching__.config = 0

    # MT_pre__classtype
    self.obj12014.MT_pre__classtype.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj12014.MT_pre__classtype.setHeight(15)

    # MT_pivotIn__
    self.obj12014.MT_pivotIn__.setValue('element1')

    # MT_label__
    self.obj12014.MT_label__.setValue('2')

    # MT_pre__name
    self.obj12014.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj12014.MT_pre__name.setHeight(15)

    self.obj12014.graphClass_= graph_MT_pre__MetaModelElement_S
    if self.genGraphics:
       new_obj = graph_MT_pre__MetaModelElement_S(260.0,460.0,self.obj12014)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__MetaModelElement_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj12014.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj12014)
    self.globalAndLocalPostcondition(self.obj12014, rootNode)
    self.obj12014.postAction( rootNode.CREATE )

    self.obj12015=MT_pre__MetaModelElement_S(self)
    self.obj12015.isGraphObjectVisual = True

    if(hasattr(self.obj12015, '_setHierarchicalLink')):
      self.obj12015._setHierarchicalLink(False)

    # MT_pivotOut__
    self.obj12015.MT_pivotOut__.setValue('element2')

    # MT_subtypeMatching__
    self.obj12015.MT_subtypeMatching__.setValue(('True', 1))
    self.obj12015.MT_subtypeMatching__.config = 0

    # MT_pre__classtype
    self.obj12015.MT_pre__classtype.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj12015.MT_pre__classtype.setHeight(15)

    # MT_pivotIn__
    self.obj12015.MT_pivotIn__.setValue('element2')

    # MT_label__
    self.obj12015.MT_label__.setValue('3')

    # MT_pre__name
    self.obj12015.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj12015.MT_pre__name.setHeight(15)

    self.obj12015.graphClass_= graph_MT_pre__MetaModelElement_S
    if self.genGraphics:
       new_obj = graph_MT_pre__MetaModelElement_S(480.0,460.0,self.obj12015)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__MetaModelElement_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj12015.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj12015)
    self.globalAndLocalPostcondition(self.obj12015, rootNode)
    self.obj12015.postAction( rootNode.CREATE )

    self.obj12016=MT_pre__MetaModelElement_S(self)
    self.obj12016.isGraphObjectVisual = True

    if(hasattr(self.obj12016, '_setHierarchicalLink')):
      self.obj12016._setHierarchicalLink(False)

    # MT_pivotOut__
    self.obj12016.MT_pivotOut__.setValue('')
    self.obj12016.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj12016.MT_subtypeMatching__.setValue(('True', 1))
    self.obj12016.MT_subtypeMatching__.config = 0

    # MT_pre__classtype
    self.obj12016.MT_pre__classtype.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj12016.MT_pre__classtype.setHeight(15)

    # MT_pivotIn__
    self.obj12016.MT_pivotIn__.setValue('')
    self.obj12016.MT_pivotIn__.setNone()

    # MT_label__
    self.obj12016.MT_label__.setValue('4')

    # MT_pre__name
    self.obj12016.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj12016.MT_pre__name.setHeight(15)

    self.obj12016.graphClass_= graph_MT_pre__MetaModelElement_S
    if self.genGraphics:
       new_obj = graph_MT_pre__MetaModelElement_S(480.0,300.0,self.obj12016)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__MetaModelElement_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj12016.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj12016)
    self.globalAndLocalPostcondition(self.obj12016, rootNode)
    self.obj12016.postAction( rootNode.CREATE )

    self.obj12013=MT_pre__MatchModel(self)
    self.obj12013.isGraphObjectVisual = True

    if(hasattr(self.obj12013, '_setHierarchicalLink')):
      self.obj12013._setHierarchicalLink(False)

    # MT_label__
    self.obj12013.MT_label__.setValue('1')

    # MT_pivotOut__
    self.obj12013.MT_pivotOut__.setValue('')
    self.obj12013.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj12013.MT_subtypeMatching__.setValue(('True', 0))
    self.obj12013.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj12013.MT_pivotIn__.setValue('')
    self.obj12013.MT_pivotIn__.setNone()

    self.obj12013.graphClass_= graph_MT_pre__MatchModel
    if self.genGraphics:
       new_obj = graph_MT_pre__MatchModel(240.0,260.0,self.obj12013)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__MatchModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj12013.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj12013)
    self.globalAndLocalPostcondition(self.obj12013, rootNode)
    self.obj12013.postAction( rootNode.CREATE )

    self.obj12018=MT_pre__match_contains(self)
    self.obj12018.isGraphObjectVisual = True

    if(hasattr(self.obj12018, '_setHierarchicalLink')):
      self.obj12018._setHierarchicalLink(False)

    # MT_label__
    self.obj12018.MT_label__.setValue('5')

    # MT_pivotOut__
    self.obj12018.MT_pivotOut__.setValue('')
    self.obj12018.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj12018.MT_subtypeMatching__.setValue(('True', 0))
    self.obj12018.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj12018.MT_pivotIn__.setValue('')
    self.obj12018.MT_pivotIn__.setNone()

    self.obj12018.graphClass_= graph_MT_pre__match_contains
    if self.genGraphics:
       new_obj = graph_MT_pre__match_contains(320.5,401.5,self.obj12018)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj12018.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj12018)
    self.globalAndLocalPostcondition(self.obj12018, rootNode)
    self.obj12018.postAction( rootNode.CREATE )

    self.obj12019=MT_pre__match_contains(self)
    self.obj12019.isGraphObjectVisual = True

    if(hasattr(self.obj12019, '_setHierarchicalLink')):
      self.obj12019._setHierarchicalLink(False)

    # MT_label__
    self.obj12019.MT_label__.setValue('6')

    # MT_pivotOut__
    self.obj12019.MT_pivotOut__.setValue('')
    self.obj12019.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj12019.MT_subtypeMatching__.setValue(('True', 0))
    self.obj12019.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj12019.MT_pivotIn__.setValue('')
    self.obj12019.MT_pivotIn__.setNone()

    self.obj12019.graphClass_= graph_MT_pre__match_contains
    if self.genGraphics:
       new_obj = graph_MT_pre__match_contains(430.5,401.5,self.obj12019)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj12019.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj12019)
    self.globalAndLocalPostcondition(self.obj12019, rootNode)
    self.obj12019.postAction( rootNode.CREATE )

    self.obj12020=MT_pre__match_contains(self)
    self.obj12020.isGraphObjectVisual = True

    if(hasattr(self.obj12020, '_setHierarchicalLink')):
      self.obj12020._setHierarchicalLink(False)

    # MT_label__
    self.obj12020.MT_label__.setValue('7')

    # MT_pivotOut__
    self.obj12020.MT_pivotOut__.setValue('')
    self.obj12020.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj12020.MT_subtypeMatching__.setValue(('True', 0))
    self.obj12020.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj12020.MT_pivotIn__.setValue('')
    self.obj12020.MT_pivotIn__.setNone()

    self.obj12020.graphClass_= graph_MT_pre__match_contains
    if self.genGraphics:
       new_obj = graph_MT_pre__match_contains(430.5,321.5,self.obj12020)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj12020.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj12020)
    self.globalAndLocalPostcondition(self.obj12020, rootNode)
    self.obj12020.postAction( rootNode.CREATE )

    self.obj12021=MT_pre__directLink_S(self)
    self.obj12021.isGraphObjectVisual = True

    if(hasattr(self.obj12021, '_setHierarchicalLink')):
      self.obj12021._setHierarchicalLink(False)

    # MT_label__
    self.obj12021.MT_label__.setValue('8')

    # MT_pivotOut__
    self.obj12021.MT_pivotOut__.setValue('')
    self.obj12021.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj12021.MT_subtypeMatching__.setValue(('True', 0))
    self.obj12021.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj12021.MT_pivotIn__.setValue('')
    self.obj12021.MT_pivotIn__.setNone()

    # MT_pre__associationType
    self.obj12021.MT_pre__associationType.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj12021.MT_pre__associationType.setHeight(15)

    self.obj12021.graphClass_= graph_MT_pre__directLink_S
    if self.genGraphics:
       new_obj = graph_MT_pre__directLink_S(540.0,422.0,self.obj12021)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj12021.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj12021)
    self.globalAndLocalPostcondition(self.obj12021, rootNode)
    self.obj12021.postAction( rootNode.CREATE )

    self.obj84=MT_post__match_contains(self)
    self.obj84.isGraphObjectVisual = True

    if(hasattr(self.obj84, '_setHierarchicalLink')):
      self.obj84._setHierarchicalLink(False)

    # MT_label__
    self.obj84.MT_label__.setValue('5')

    # MT_pivotOut__
    self.obj84.MT_pivotOut__.setValue('')
    self.obj84.MT_pivotOut__.setNone()

    self.obj84.graphClass_= graph_MT_post__match_contains
    if self.genGraphics:
       new_obj = graph_MT_post__match_contains(862.0,401.5,self.obj84)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj84.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj84)
    self.globalAndLocalPostcondition(self.obj84, rootNode)
    self.obj84.postAction( rootNode.CREATE )

    self.obj85=MT_post__match_contains(self)
    self.obj85.isGraphObjectVisual = True

    if(hasattr(self.obj85, '_setHierarchicalLink')):
      self.obj85._setHierarchicalLink(False)

    # MT_label__
    self.obj85.MT_label__.setValue('6')

    # MT_pivotOut__
    self.obj85.MT_pivotOut__.setValue('')
    self.obj85.MT_pivotOut__.setNone()

    self.obj85.graphClass_= graph_MT_post__match_contains
    if self.genGraphics:
       new_obj = graph_MT_post__match_contains(972.0,401.5,self.obj85)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj85.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj85)
    self.globalAndLocalPostcondition(self.obj85, rootNode)
    self.obj85.postAction( rootNode.CREATE )

    self.obj86=MT_post__match_contains(self)
    self.obj86.isGraphObjectVisual = True

    if(hasattr(self.obj86, '_setHierarchicalLink')):
      self.obj86._setHierarchicalLink(False)

    # MT_label__
    self.obj86.MT_label__.setValue('7')

    # MT_pivotOut__
    self.obj86.MT_pivotOut__.setValue('')
    self.obj86.MT_pivotOut__.setNone()

    self.obj86.graphClass_= graph_MT_post__match_contains
    if self.genGraphics:
       new_obj = graph_MT_post__match_contains(972.0,321.5,self.obj86)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj86.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj86)
    self.globalAndLocalPostcondition(self.obj86, rootNode)
    self.obj86.postAction( rootNode.CREATE )

    self.obj70=MT_post__MetaModelElement_S(self)
    self.obj70.isGraphObjectVisual = True

    if(hasattr(self.obj70, '_setHierarchicalLink')):
      self.obj70._setHierarchicalLink(False)

    # MT_label__
    self.obj70.MT_label__.setValue('2')

    # MT_pivotOut__
    self.obj70.MT_pivotOut__.setValue('element1')

    # MT_post__classtype
    self.obj70.MT_post__classtype.setValue('\n#===============================================================================\n# You can access the value of the current node\'s attribute value by: attr_value.\n# If the current node shall be created you MUST initialize it here!\n# You can access a node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# Note that the attribute values are those before the match is rewritten.\n# The order in which this code is executed depends on the label value\n# of the encapsulating node.\n# The given action must return the new value of the attribute.\n#===============================================================================\n\nreturn attr_value\n')
    self.obj70.MT_post__classtype.setHeight(15)

    # MT_post__name
    self.obj70.MT_post__name.setValue('\n#===============================================================================\n# You can access the value of the current node\'s attribute value by: attr_value.\n# If the current node shall be created you MUST initialize it here!\n# You can access a node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# Note that the attribute values are those before the match is rewritten.\n# The order in which this code is executed depends on the label value\n# of the encapsulating node.\n# The given action must return the new value of the attribute.\n#===============================================================================\n\nreturn attr_value\n')
    self.obj70.MT_post__name.setHeight(15)

    self.obj70.graphClass_= graph_MT_post__MetaModelElement_S
    if self.genGraphics:
       new_obj = graph_MT_post__MetaModelElement_S(800.0,460.0,self.obj70)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__MetaModelElement_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj70.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj70)
    self.globalAndLocalPostcondition(self.obj70, rootNode)
    self.obj70.postAction( rootNode.CREATE )

    self.obj71=MT_post__MetaModelElement_S(self)
    self.obj71.isGraphObjectVisual = True

    if(hasattr(self.obj71, '_setHierarchicalLink')):
      self.obj71._setHierarchicalLink(False)

    # MT_label__
    self.obj71.MT_label__.setValue('3')

    # MT_pivotOut__
    self.obj71.MT_pivotOut__.setValue('element2')

    # MT_post__classtype
    self.obj71.MT_post__classtype.setValue('\n#===============================================================================\n# You can access the value of the current node\'s attribute value by: attr_value.\n# If the current node shall be created you MUST initialize it here!\n# You can access a node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# Note that the attribute values are those before the match is rewritten.\n# The order in which this code is executed depends on the label value\n# of the encapsulating node.\n# The given action must return the new value of the attribute.\n#===============================================================================\n\nreturn attr_value\n')
    self.obj71.MT_post__classtype.setHeight(15)

    # MT_post__name
    self.obj71.MT_post__name.setValue('\n#===============================================================================\n# You can access the value of the current node\'s attribute value by: attr_value.\n# If the current node shall be created you MUST initialize it here!\n# You can access a node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# Note that the attribute values are those before the match is rewritten.\n# The order in which this code is executed depends on the label value\n# of the encapsulating node.\n# The given action must return the new value of the attribute.\n#===============================================================================\n\nreturn attr_value\n')
    self.obj71.MT_post__name.setHeight(15)

    self.obj71.graphClass_= graph_MT_post__MetaModelElement_S
    if self.genGraphics:
       new_obj = graph_MT_post__MetaModelElement_S(1020.0,460.0,self.obj71)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__MetaModelElement_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj71.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj71)
    self.globalAndLocalPostcondition(self.obj71, rootNode)
    self.obj71.postAction( rootNode.CREATE )

    self.obj72=MT_post__MetaModelElement_S(self)
    self.obj72.isGraphObjectVisual = True

    if(hasattr(self.obj72, '_setHierarchicalLink')):
      self.obj72._setHierarchicalLink(False)

    # MT_label__
    self.obj72.MT_label__.setValue('4')

    # MT_pivotOut__
    self.obj72.MT_pivotOut__.setValue('')
    self.obj72.MT_pivotOut__.setNone()

    # MT_post__classtype
    self.obj72.MT_post__classtype.setValue('\n#===============================================================================\n# You can access the value of the current node\'s attribute value by: attr_value.\n# If the current node shall be created you MUST initialize it here!\n# You can access a node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# Note that the attribute values are those before the match is rewritten.\n# The order in which this code is executed depends on the label value\n# of the encapsulating node.\n# The given action must return the new value of the attribute.\n#===============================================================================\n\nreturn attr_value\n')
    self.obj72.MT_post__classtype.setHeight(15)

    # MT_post__name
    self.obj72.MT_post__name.setValue('\n#===============================================================================\n# You can access the value of the current node\'s attribute value by: attr_value.\n# If the current node shall be created you MUST initialize it here!\n# You can access a node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# Note that the attribute values are those before the match is rewritten.\n# The order in which this code is executed depends on the label value\n# of the encapsulating node.\n# The given action must return the new value of the attribute.\n#===============================================================================\n\nreturn attr_value\n')
    self.obj72.MT_post__name.setHeight(15)

    self.obj72.graphClass_= graph_MT_post__MetaModelElement_S
    if self.genGraphics:
       new_obj = graph_MT_post__MetaModelElement_S(1020.0,300.0,self.obj72)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__MetaModelElement_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj72.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj72)
    self.globalAndLocalPostcondition(self.obj72, rootNode)
    self.obj72.postAction( rootNode.CREATE )

    self.obj88=MT_post__directLink_S(self)
    self.obj88.isGraphObjectVisual = True

    if(hasattr(self.obj88, '_setHierarchicalLink')):
      self.obj88._setHierarchicalLink(False)

    # MT_label__
    self.obj88.MT_label__.setValue('9')

    # MT_pivotOut__
    self.obj88.MT_pivotOut__.setValue('')
    self.obj88.MT_pivotOut__.setNone()

    # MT_post__associationType
    self.obj88.MT_post__associationType.setValue('\n#===============================================================================\n# You can access the value of the current node\'s attribute value by: attr_value.\n# If the current node shall be created you MUST initialize it here!\n# You can access a node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# Note that the attribute values are those before the match is rewritten.\n# The order in which this code is executed depends on the label value\n# of the encapsulating node.\n# The given action must return the new value of the attribute.\n#===============================================================================\n\nreturn attr_value\n')
    self.obj88.MT_post__associationType.setHeight(15)

    self.obj88.graphClass_= graph_MT_post__directLink_S
    if self.genGraphics:
       new_obj = graph_MT_post__directLink_S(970.0,422.0,self.obj88)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__directLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj88.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj88)
    self.globalAndLocalPostcondition(self.obj88, rootNode)
    self.obj88.postAction( rootNode.CREATE )

    self.obj69=MT_post__MatchModel(self)
    self.obj69.isGraphObjectVisual = True

    if(hasattr(self.obj69, '_setHierarchicalLink')):
      self.obj69._setHierarchicalLink(False)

    # MT_label__
    self.obj69.MT_label__.setValue('1')

    # MT_pivotOut__
    self.obj69.MT_pivotOut__.setValue('')
    self.obj69.MT_pivotOut__.setNone()

    self.obj69.graphClass_= graph_MT_post__MatchModel
    if self.genGraphics:
       new_obj = graph_MT_post__MatchModel(780.0,260.0,self.obj69)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__MatchModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj69.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj69)
    self.globalAndLocalPostcondition(self.obj69, rootNode)
    self.obj69.postAction( rootNode.CREATE )

    self.obj64=RHS(self)
    self.obj64.isGraphObjectVisual = True

    if(hasattr(self.obj64, '_setHierarchicalLink')):
      self.obj64._setHierarchicalLink(False)

    # action
    self.obj64.action.setValue('#===============================================================================\n# This code is executed after the rule has been applied.\n# You can access a node labelled n matched by this rule by: PostNode(\'n\').\n# To access attribute x of node n, use: PostNode(\'n\')[\'x\'].\n#===============================================================================\n\npass\n')
    self.obj64.action.setHeight(15)

    self.obj64.graphClass_= graph_RHS
    if self.genGraphics:
       new_obj = graph_RHS(660.0,200.0,self.obj64)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("RHS", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj64.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj64)
    self.globalAndLocalPostcondition(self.obj64, rootNode)
    self.obj64.postAction( rootNode.CREATE )

    self.obj63=LHS(self)
    self.obj63.isGraphObjectVisual = True

    if(hasattr(self.obj63, '_setHierarchicalLink')):
      self.obj63._setHierarchicalLink(False)

    # constraint
    self.obj63.constraint.setValue('#===============================================================================\n# This code is executed after the nodes in the LHS have been matched.\n# You can access a matched node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# The given constraint must evaluate to a boolean expression:\n#    returning True enables the rule to be applied,\n#    returning False forbids the rule from being applied.\n#===============================================================================\n\nreturn True\n')
    self.obj63.constraint.setHeight(15)

    self.obj63.graphClass_= graph_LHS
    if self.genGraphics:
       new_obj = graph_LHS(200.0,200.0,self.obj63)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("LHS", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj63.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj63)
    self.globalAndLocalPostcondition(self.obj63, rootNode)
    self.obj63.postAction( rootNode.CREATE )

    # Connections for obj12014 (graphObject_: Obj20) of type MT_pre__MetaModelElement_S
    self.drawConnections(
 )
    # Connections for obj12015 (graphObject_: Obj21) of type MT_pre__MetaModelElement_S
    self.drawConnections(
(self.obj12015,self.obj12021,[540.0, 502.0, 540.0, 422.0],"true", 2) )
    # Connections for obj12016 (graphObject_: Obj22) of type MT_pre__MetaModelElement_S
    self.drawConnections(
 )
    # Connections for obj12013 (graphObject_: Obj19) of type MT_pre__MatchModel
    self.drawConnections(
(self.obj12013,self.obj12018,[321.0, 301.0, 320.5, 401.5],"true", 2),
(self.obj12013,self.obj12019,[321.0, 301.0, 430.5, 401.5],"true", 2),
(self.obj12013,self.obj12020,[321.0, 301.0, 430.5, 321.5],"true", 2) )
    # Connections for obj12018 (graphObject_: Obj24) of type MT_pre__match_contains
    self.drawConnections(
(self.obj12018,self.obj12014,[320.5, 401.5, 320.0, 502.0],"true", 2) )
    # Connections for obj12019 (graphObject_: Obj25) of type MT_pre__match_contains
    self.drawConnections(
(self.obj12019,self.obj12015,[430.5, 401.5, 540.0, 502.0],"true", 2) )
    # Connections for obj12020 (graphObject_: Obj26) of type MT_pre__match_contains
    self.drawConnections(
(self.obj12020,self.obj12016,[430.5, 321.5, 540.0, 342.0],"true", 2) )
    # Connections for obj12021 (graphObject_: Obj27) of type MT_pre__directLink_S
    self.drawConnections(
(self.obj12021,self.obj12016,[540.0, 422.0, 540.0, 342.0],"true", 2) )
    # Connections for obj84 (graphObject_: Obj13) of type MT_post__match_contains
    self.drawConnections(
(self.obj84,self.obj70,[862.0, 401.5, 860.0, 502.0],"true", 2) )
    # Connections for obj85 (graphObject_: Obj14) of type MT_post__match_contains
    self.drawConnections(
(self.obj85,self.obj71,[972.0, 401.5, 1080.0, 502.0],"true", 2) )
    # Connections for obj86 (graphObject_: Obj15) of type MT_post__match_contains
    self.drawConnections(
(self.obj86,self.obj72,[972.0, 321.5, 1080.0, 342.0],"true", 2) )
    # Connections for obj70 (graphObject_: Obj7) of type MT_post__MetaModelElement_S
    self.drawConnections(
(self.obj70,self.obj88,[860.0, 502.0, 970.0, 422.0],"true", 2) )
    # Connections for obj71 (graphObject_: Obj8) of type MT_post__MetaModelElement_S
    self.drawConnections(
 )
    # Connections for obj72 (graphObject_: Obj9) of type MT_post__MetaModelElement_S
    self.drawConnections(
 )
    # Connections for obj88 (graphObject_: Obj17) of type MT_post__directLink_S
    self.drawConnections(
(self.obj88,self.obj72,[970.0, 422.0, 1080.0, 342.0],"true", 2) )
    # Connections for obj69 (graphObject_: Obj6) of type MT_post__MatchModel
    self.drawConnections(
(self.obj69,self.obj84,[864.0, 301.0, 862.0, 401.5],"true", 2),
(self.obj69,self.obj85,[864.0, 301.0, 972.0, 401.5],"true", 2),
(self.obj69,self.obj86,[864.0, 301.0, 972.0, 321.5],"true", 2) )
    # Connections for obj64 (graphObject_: Obj1) of type RHS
    self.drawConnections(
 )
    # Connections for obj63 (graphObject_: Obj0) of type LHS
    self.drawConnections(
 )

newfunction = move_one_output_direct_match_MDL

loadedMMName = ['MT_post__SimpleDSLTransMM_META', 'MoTifRule_META', 'MT_pre__SimpleDSLTransMM_META']

atom3version = '0.3'
